/**
 * 状态机辅助工具
 * 提供便捷的状态机操作接口，使用level命名法
 */

// 直接引入状态机模块
const researchStateMachine = require('../../store/modules/research/research_state_machine');
const researchStateMachineStore = researchStateMachine.researchStateMachineStore;

/**
 * 状态字段定义
 */
const FIELDS = {
  LEVEL1: 'level1',
  LEVEL2: 'level2',
  LEVEL3: 'level3',
  LEVEL4: 'level4'
};

/**
 * 状态常量
 */
const STATE = researchStateMachine.PROJECT_STATUS;
const ACTIVE_STATE = researchStateMachine.ACTIVE_STATE;

/**
 * 获取项目当前状态的描述
 * @param {Object} project 项目数据
 * @returns {string} 状态描述
 */
function getProjectStateDesc(project) {
  if (!project) return '未知状态';
  
  // 获取状态值 - 使用level字段
  const level1 = project[FIELDS.LEVEL1];
  const level2 = project[FIELDS.LEVEL2];
  const level3 = project[FIELDS.LEVEL3];
  const level4 = project[FIELDS.LEVEL4];
  
  // 获取主状态名称
  const statusName = getStatusName(level1);
  
  // 如果是活动状态，展示活动详情
  if (level1 === STATE.ACTIVE && level3) {
    // 获取活动状态名称
    let activeStateName = '';
    for (const key in ACTIVE_STATE) {
      if (ACTIVE_STATE[key] === level3) {
        activeStateName = key;
        break;
      }
    }
    
    // 如果有子状态，则展示子状态
    if (level4) {
      return `${statusName} - ${activeStateName} - ${level4}`;
    }
    
    return `${statusName} - ${activeStateName}`;
  }
  
  // 如果是其他状态且有子状态，展示子状态
  if (level2) {
    return `${statusName} - ${getSubStatusName(level1, level2)}`;
  }
  
  return statusName;
}

// 获取状态名称
function getStatusName(status) {
  const statusMap = {
    [STATE.NONE]: '初始状态',
    [STATE.REVIEWING]: '项目审核',
    [STATE.DORMANT]: '休眠',
    [STATE.ACTIVE]: '活动',
    [STATE.COMPLETED]: '已完成'
  };
  
  return statusMap[status] || '未知状态';
}

// 获取子状态名称
function getSubStatusName(status, subStatus) {
  // 简单实现，实际应根据状态机定义
  return subStatus || '未知子状态';
}

/**
 * 获取项目状态进度百分比
 * @param {Object} project 项目数据
 * @returns {number} 进度百分比，0-100
 */
function getProjectProgress(project) {
  if (!project) return 0;
  
  // 获取状态值
  const level1 = project[FIELDS.LEVEL1];
  
  // 基础进度
  let baseProgress = 0;
  
  switch (level1) {
    case STATE.REVIEWING:
      baseProgress = 10;
      break;
    case STATE.DORMANT:
      baseProgress = 0;
      break;
    case STATE.ACTIVE:
      baseProgress = 20;
      break;
    case STATE.COMPLETED:
      return 100;
    default:
      return 0;
  }
  
  // 如果是活动状态，根据活动阶段计算进度
  if (level1 === STATE.ACTIVE) {
    const level3 = project[FIELDS.LEVEL3];
    
    // 根据活动阶段设置额外进度
    switch (level3) {
      case ACTIVE_STATE.HARDWARE_CONFIRM:
        return baseProgress + 5;
      case ACTIVE_STATE.HARDWARE_DESIGN_SAMPLE:
        return baseProgress + 10;
      case ACTIVE_STATE.SW_HW_DEBUG:
        return baseProgress + 20;
      case ACTIVE_STATE.DATA_SYNC:
        return baseProgress + 25;
      case ACTIVE_STATE.TESTING:
        return baseProgress + 30;
      case ACTIVE_STATE.CUSTOMER_CONFIRM:
        return baseProgress + 50;
      case ACTIVE_STATE.ORDER_PREPARATION:
        return baseProgress + 70;
      case ACTIVE_STATE.PRODUCTION:
        return baseProgress + 85;
      case ACTIVE_STATE.PRODUCT_FEEDBACK:
        return baseProgress + 95;
      default:
        return baseProgress;
    }
  }
  
  return baseProgress;
}

/**
 * 获取项目当前可用的操作
 * @param {Object} project 项目数据
 * @param {string} userRole 用户角色
 * @returns {Array} 可用操作列表
 */
function getAvailableActions(project, userRole) {
  if (!project || !userRole) return [];
  
  try {
    // 设置项目和角色
    researchStateMachineStore.setProject(project);
    researchStateMachineStore.setCurrentRole(userRole);
    
    // 获取可用事件
    return researchStateMachineStore._getAvailableEventsForCurrentState();
  } catch (error) {
    console.error('[状态机] 获取可用操作失败:', error);
    return [];
  }
}

/**
 * 检查是否可以执行指定事件
 * @param {Object} project 项目数据
 * @param {string} userRole 用户角色
 * @param {string} eventId 事件ID
 * @returns {boolean} 是否可执行
 */
function canExecuteEvent(project, userRole, eventId) {
  if (!project || !userRole || !eventId) return false;
  
  try {
    // 设置项目和角色
    researchStateMachineStore.setProject(project);
    researchStateMachineStore.setCurrentRole(userRole);
    
    // 检查是否可执行
    const availableEvents = researchStateMachineStore._getAvailableEventsForCurrentState();
    return availableEvents.includes(eventId);
  } catch (error) {
    console.error('[状态机] 检查事件可执行性失败:', error);
    return false;
  }
}

/**
 * 执行状态转换
 * @param {Object} project 项目数据
 * @param {string} eventId 事件ID
 * @param {Object} formData 表单数据
 * @returns {Promise<Object>} 转换结果
 */
async function executeTransition(project, eventId, formData = {}) {
  if (!project || !eventId) {
    return { success: false, message: '参数不完整' };
  }
  
  // 执行转换
  try {
    // 先设置项目
    researchStateMachineStore.setProject(project);
    
    // 简单实现，实际需要根据状态机调用后端API
    return { 
      success: true, 
      message: '模拟执行状态转换成功',
      result: { 
        projectId: project._id,
        eventId,
        formData
      }
    };
  } catch (error) {
    console.error('[状态机] 执行转换失败:', error);
    return { success: false, message: error.message || '执行状态转换失败' };
  }
}

// 导出函数
module.exports = {
  FIELDS,
  STATE,
  ACTIVE_STATE,
  getProjectStateDesc,
  getProjectProgress,
  getAvailableActions,
  canExecuteEvent,
  executeTransition
}; 